#include <docker.h>
/**
 * 构建 mysql 服务
 *
 * @return 构建结果，0 表示成功，-1 表示失败
 */
int DockerContainer::mysqlServices(string name){
    VesselServices vs;
    vs.name=name;// 服务名称

    // 服务镜像
    const char* mysql_image=getenv("DOCKER_VESSEL_MYSQL_IMAGE");
    if(mysql_image==nullptr){
        cout<<"mysql 服务镜像为空 将设置默认 mysql:9.0.1"<<endl;
        vs.image="mysql:9.0.1";
    }else{
        cout<<"mysql 服务镜像设置为: "<<mysql_image<<endl;
        vs.image=string(mysql_image);
    }
    // ipv4
    const char* mysql_ipv4=getenv("DOCKER_VESSEL_MYSQL_IPV4");
    if(mysql_ipv4==nullptr){
        string ipv4=this->getIp("240");
        vs.ip=ipv4;
        cout<<"mysql 服务 ipv4 为空 将设置默认 "<<ipv4<<endl;
    }else{
        string ipv4=this->getIp(string(mysql_ipv4));
        vs.ip=ipv4;
        cout<<"mysql 服务 ipv4 设置为: "<<ipv4<<endl;
    }
    // mysql root 密码
    const char* mysql_root_password=getenv("DOCKER_VESSEL_MYSQL_ENVIRONMENT");
    if(mysql_root_password==nullptr){
        cout<<"mysql 服务 root 密码为空 将设置默认 1234567890"<<endl;
        vs.envs.push_back("MYSQL_ROOT_PASSWORD=1234567890");
    }else{
        cout<<"mysql 服务 root 密码设置为: "<<mysql_root_password<<endl;
        vs.envs.push_back("MYSQL_ROOT_PASSWORD="+string(mysql_root_password));
    }
    // mysql 端口
    const char* mysql_port=getenv("DOCKER_VESSEL_MYSQL_PORTS");
    if(mysql_port !=nullptr){
        string ports=string(mysql_port)+":3306";
        cout<<"mysql 服务端口设置为: "<<ports<<endl;
        vs.ports.push_back(ports);
        vs.ports.push_back("33060:33060");
    }
    // mysql 卷
    const char* mysql_volume=getenv("DOCKER_VESSEL_MYSQL_VOLUMES");
    if(mysql_volume!=nullptr){
        string volumes=this->rootVolume+string(mysql_volume)+":/var/lib/mysql";
        cout<<"mysql 服务卷设置为: "<<volumes<<endl;
        vs.volumes.push_back(volumes);
    }
   this->mVessel.insert({name,vs});
   this->addServices(vs);
    return 0;
}

int DockerContainer::redisServices(string name){
    VesselServices vs;
    vs.name=name;// 服务名称

    // 服务镜像
    const char* image=getenv("DOCKER_VESSEL_REDIS_IMAGE");
    if(image==nullptr){
        cout<<"redis 服务镜像为空 将设置默认 redis:7.4.0"<<endl;
        vs.image="redis:7.4.0";
    }else{
        cout<<"redis 服务镜像设置为: "<<image<<endl;
        vs.image=string(image);
    }
    // ipv4
    const char* ipv4=getenv("DOCKER_VESSEL_REDIS_IPV4");
    string ip;
    if(ipv4==nullptr){
        ip=this->getIp("241");
    }else{
       ip=this->getIp(string(ipv4));
    }
    vs.ip=ip;
    cout<<"redis 服务 ipv4 设置为: "<<ip<<endl;
    // redis 端口
    const char* port=getenv("DOCKER_VESSEL_REDIS_PORTS");
    if(port != nullptr){
        string ports=string(port)+":6379";
        cout<<"redis 服务端口设置为: "<<ports<<endl;
        vs.ports.push_back(ports);

    }
    // 命令启动
    const char* command=getenv("DOCKER_VESSEL_REDIS_COMMAND");
    if(command == nullptr){
        string rcmd="--appendonly yes --requirepass 1234567890";
        vs.command=rcmd;
        cout<<"redis 服务命令启动设置为: "<<rcmd<<endl;
    }else{
        vs.command=string(command);
        cout<<"redis 服务命令启动设置为: "<<command<<endl;
    }
    this->mVessel.insert({name,vs});
    this->addServices(vs);
    return 0;
}

int DockerContainer::nexus3Services(string name){
    VesselServices vs;
    vs.name=name;// 服务名称
    // 服务镜像
    const char* image=getenv("DOCKER_VESSEL_NEXUS3_IMAGE");
    if(image==nullptr){
        cout<<"nexus3 服务镜像为空 将设置默认 sonatype/nexus3:3.65.1"<<endl;
        vs.image="sonatype/nexus3:latest";
    }else{
        cout<<"nexus3 服务镜像设置为: "<<image<<endl;
        vs.image=string(image);
    }
    // ipv4
    const char* ipv4=getenv("DOCKER_VESSEL_NEXUS3_IPV4");
    if(ipv4==nullptr){
        string ip=this->getIp("242");
        vs.ip=ip;
        cout<<"nexus3 服务 ipv4 为空 将设置默认 "<<ip<<endl;
    }
    else{
        string ip=this->getIp(string(ipv4));
        vs.ip=ip;
        cout<<"nexus3 服务 ipv4 设置为: "<<ip<<endl;
    }
    // nexus3 端口
    const char* port=getenv("DOCKER_VESSEL_NEXUS3_PORTS");
    if(port != nullptr){
        string ports=string(port)+":8081";
        cout<<"nexus3 服务端口设置为: "<<ports<<endl;
        vs.ports.push_back(ports);
    }
    // nexus3 卷
    const char* volume=getenv("DOCKER_VESSEL_NEXUS3_VOLUMES");
    if(volume!= nullptr){
        string volumes=this->rootVolume+string(volume)+":/nexus-data";
        cout<<"nexus3 服务卷设置为: "<<volumes<<endl;
        vs.volumes.push_back(volumes);
    }
    this->mVessel.insert({name,vs});
    this->addServices(vs);
    return 0;
}

int DockerContainer::alistServices(string name){
    VesselServices vs;
    vs.name=name;// 服务名称
    // 服务镜像
    const char* image=getenv("DOCKER_VESSEL_ALIST_IMAGE");
    if(image==nullptr){
        cout<<"alist 服务镜像为空 将设置默认 xhofe/alist:latest"<<endl;
        vs.image="xhofe/alist:latest";
    }else{
        cout<<"alist 服务镜像设置为: "<<image<<endl;
        vs.image=string(image);
    }
    // ipv4
    const char* ipv4=getenv("DOCKER_VESSEL_ALIST_IPV4");
    if(ipv4==nullptr){
        string ip=this->getIp("243");
        vs.ip=ip;
    }else{
        string ip=this->getIp(string(ipv4));
        vs.ip=ip;
    }
    // alist 端口
    const char* port=getenv("DOCKER_VESSEL_ALIST_PORTS");
    if(port!= nullptr){
        string ports=string(port)+":5244";
    }
    // alist 卷
    const char* volume=getenv("DOCKER_VESSEL_ALIST_VOLUMES");
    if(volume!= nullptr){
        string volumes=this->rootVolume+string(volume)+":/opt/alist/data";
        vs.volumes.push_back(volumes);
    }
    this->mVessel.insert({name,vs});
    this->addServices(vs);
    return 0;
}

int DockerContainer::aria2Services(string name){
    VesselServices vs;
    vs.name=name;// 服务名称
    // 服务镜像
    const char* image=getenv("DOCKER_VESSEL_ARIA2_IMAGE");
    if(image==nullptr){
        cout<<"aria2 服务镜像为空 将设置默认 p3terx/aria2-pro:latest"<<endl;
        vs.image="p3terx/aria2-pro:latest";
    }
    else{
        cout<<"aria2 服务镜像设置为: "<<image<<endl;
        vs.image=string(image);
    }
    // ipv4
    const char* ipv4=getenv("DOCKER_VESSEL_ARIA2_IPV4");
    if(ipv4==nullptr){
        string ip=this->getIp("244");
        vs.ip=ip;
        cout<<"aria2 服务 ipv4 为空 将设置默认 "<<ip<<endl;
    }else{
        string ip=this->getIp(string(ipv4));
        vs.ip=ip;
        cout<<"aria2 服务 ipv4 设置为: "<<ip<<endl;
    }
    // aria2 端口
    const char* port=getenv("DOCKER_VESSEL_ARIA2_PORTS");
    if(port!= nullptr){
        string ports=string(port)+":6800";
        cout<<"aria2 服务端口设置为: "<<ports<<endl;
        vs.ports.push_back(ports);
    }
    // rpc服务密钥
    const char* secret=getenv("DOCKER_VESSEL_ARIA2_ENVIRONMENT_RPC_SECRET");
    if(secret==nullptr){
        cout<<"aria2 服务 rpc 服务密钥为空 将设置默认 1234567890"<<endl;
        vs.envs.push_back("RPC_SECRET=1234567890");
    }else{
        cout<<"aria2 服务 rpc 服务密钥设置为: "<<secret<<endl;
        vs.envs.push_back("RPC_SECRET="+string(secret));
    }
    // aria2 配置文件目录 环境变量
    const char* conf_dir=getenv("DOCKER_VESSEL_ARIA2_ENVIRONMENT_ARIA2_CONF_DIR");
    string sconf_dir;
    if(conf_dir==nullptr){
        sconf_dir="/etc/aria2";
    }else{
        sconf_dir=string(conf_dir);
    }
    cout<<"aria2 服务 配置文件 环境变量设置为: "<<sconf_dir<<endl;
    vs.envs.push_back("ARIA2_CONF_DIR="+sconf_dir);
    // aria2 下载目录 环境变量
    const char* dowload_dir=getenv("DOCKER_VESSEL_ARIA2_ENVIRONMENT_DOWLOAD_DIR");
    string sdowload_dir;
    if(dowload_dir==nullptr){
      sdowload_dir="/downloads";
    }else{
        sdowload_dir=string(dowload_dir);
    }
    cout<<"aria2 服务 下载目录 环境变量设置为: "<<sdowload_dir<<endl;
    vs.envs.push_back("DOWLOAD_DIR="+sdowload_dir);
    const char* varia2=getenv("DOCKER_VESSEL_ARIA2_VOLUMES_ARIA2");
    if(varia2 !=nullptr){
        string voaria2=this->rootVolume+string(varia2)+":"+sconf_dir;
        cout<<"aria2 服务 配置文件 卷为空 将设置默认 "<<voaria2<<endl;
        vs.volumes.push_back(voaria2);
    }
    const char* dowload=getenv("DOCKER_VESSEL_ARIA2_VOLUMES_DOWNLOADS");
    if(dowload!=nullptr){
        string vodowload=this->rootVolume+string(dowload)+":"+sdowload_dir;
        cout<<"aria2 服务 下载目录 卷为空 将设置默认 "<<vodowload<<endl;
        vs.volumes.push_back(vodowload);
    }
    this->mVessel.insert({name,vs});
    this->addServices(vs);
    return 0;
}

int DockerContainer::videoServices(string name){
    // 视频服务
    VesselServices vs;
    vs.name=name;// 服务名称
    // 服务镜像
    const char* image=getenv("DOCKER_VESSEL_VIDEO_IMAGE");
    string simage;
    if(image==nullptr){
        simage="crpi-vb403qyxdijc0eq9.cn-guangzhou.personal.cr.aliyuncs.com/utlis/build:ubuntu-22.04-video_services";
    }else{
        simage=string(image);
    }
    vs.image=simage;
    cout<<"视频服务 镜像设置为: "<<simage<<endl;
    const char* ipv4=getenv("DOCKER_VESSEL_VIDEO_IPV4");
    string sipv4;
    if(ipv4==nullptr){
        sipv4=this->getIp("245");
    }else{
        sipv4=this->getIp(string(ipv4));
    }
    vs.ip=sipv4;
    cout<<"视频服务 ipv4 设置为: "<<sipv4<<endl;

    const char* port=getenv("DOCKER_VESSEL_VIDEO_PORT");
    if(port!= nullptr){
        string sport=string(port)+":80";
        cout<<"视频服务 端口设置为: "<<sport<<endl;
        vs.ports.push_back(sport);
    }
    const char* prefix=getenv("DOCKER_VESSEL_VIDEO_ENVIRONMENT_PREFIX");
    string sprefix;
    if(prefix==nullptr){
        sprefix="/usr/local";
    }else{
        sprefix=string(prefix);
    }
    cout<<"视频服务 环境变量 PREFIX 设置为: "<<sprefix<<endl;
    vs.envs.push_back("PREFIX="+sprefix);
    // app 内部端口
    const char* app_port=getenv("DOCKER_VESSEL_VIDEO_APP_PORT");
    string sapp_port;
    if(app_port == nullptr){
        sapp_port="SERVER_PORT=80";
    }else{
        sapp_port="SERVER_PORT="+string(app_port);
    }
    cout<<"视频服务 环境变量 SERVER_PORT 设置为: "<<sapp_port<<endl;
    vs.envs.push_back(sapp_port);
    // mysql host
    const char* mysql_host=getenv("DOCKER_VESSEL_VIDEO_MYSQL_HOST");
    string smysql_host;
    if(mysql_host==nullptr){
        smysql_host="MYSQL_HOST=192.168.10.253";
    }else{
        smysql_host="MYSQL_HOST="+string(mysql_host);
    }
    cout<<"视频服务 环境变量 MYSQL_HOST 设置为: "<<smysql_host<<endl;
    vs.envs.push_back(smysql_host);
    // mysql port
    const char* mysql_port=getenv("DOCKER_VESSEL_VIDEO_MYSQL_PORT");
    string smysql_port;
    if(mysql_port==nullptr){
        smysql_port="MYSQL_PORT=3306";
    }else{
        smysql_port="MYSQL_PORT="+string(mysql_port);
    }
    cout<<"视频服务 环境变量 MYSQL_PORT 设置为: "<<smysql_port<<endl;
    vs.envs.push_back(smysql_port);
    // mysql database
    const char* mysql_database=getenv("DOCKER_VESSEL_VIDEO_MYSQL_DATABASE");
    string smysql_database;
    if(mysql_database==nullptr){
        smysql_database="MYSQL_DATABASE=video";
    }else{
        smysql_database="MYSQL_DATABASE="+string(mysql_database);
    }
    cout<<"视频服务 环境变量 MYSQL_DATABASE 设置为: "<<smysql_database<<endl;
    vs.envs.push_back(smysql_database);

    // mysql user
    const char* mysql_user=getenv("DOCKER_VESSEL_VIDEO_MYSQL_USER");
    string smysql_user;
    if(mysql_user==nullptr){
        smysql_user="MYSQL_USER=root";
    }else{
        smysql_user="MYSQL_USER="+string(mysql_user);
    }
    cout<<"视频服务 环境变量 MYSQL_USER 设置为: "<<smysql_user<<endl;
    vs.envs.push_back(smysql_user);
    // mysql password
    const char* mysql_password=getenv("DOCKER_VESSEL_VIDEO_MYSQL_PASSWORD");
    string smysql_password;
    if(mysql_password==nullptr){
        smysql_password="MYSQL_PASSWORD=1234567890";
    }else{
        smysql_password="MYSQL_PASSWORD="+string(mysql_password);
    }
    cout<<"视频服务 环境变量 MYSQL_PASSWORD 设置为: "<<smysql_password<<endl;
    vs.envs.push_back(smysql_password);
    // redis host
    const char* redis_host=getenv("DOCKER_VESSEL_VIDEO_REDIS_HOST");
    string sredis_host;
    if(redis_host==nullptr){
       sredis_host="REDIS_HOST=192.168.10.253";
    }else{
        sredis_host="REDIS_HOST="+string(redis_host);
    }
    cout<<"视频服务 环境变量 REDIS_HOST 设置为: "<<sredis_host<<endl;
    vs.envs.push_back(sredis_host);
    // redis port
    const char* redis_port=getenv("DOCKER_VESSEL_VIDEO_REDIS_PORT");
    string sredis_port;
    if(redis_port==nullptr){
        sredis_port="REDIS_PORT=6379";
    }else{
        sredis_port="REDIS_PORT="+string(redis_port);
    }
    cout<<"视频服务 环境变量 REDIS_PORT 设置为: "<<sredis_port<<endl;
    vs.envs.push_back(sredis_port);

    // redis database
    const char* redis_database=getenv("DOCKER_VESSEL_VIDEO_REDIS_DATABASE");
    string sredis_database;
    if(redis_database==nullptr){
        sredis_database="REDIS_DATABASE=0";
    }else{
        sredis_database="REDIS_DATABASE="+string(redis_database);
    }
    cout<<"视频服务 环境变量 REDIS_DATABASE 设置为: "<<sredis_database<<endl;
    vs.envs.push_back(sredis_database);

    // redis password
    const char* redis_password=getenv("DOCKER_VESSEL_VIDEO_REDIS_PASSWORD");
    string sredis_password;
    if(redis_password==nullptr){
        sredis_password="REDIS_PASSWORD=1234567890";
    }else{
        sredis_password="REDIS_PASSWORD="+string(redis_password);
    }
    cout<<"视频服务 环境变量 REDIS_PASSWORD 设置为: "<<sredis_password<<endl;
    vs.envs.push_back(sredis_password);
    // 视频服务 卷设置
    const char* videoDir=getenv("DOCKER_VESSEL_VIDEO_VOLUMES");
    if(videoDir != nullptr){
        string svideoDir=this->rootVolume+string(videoDir)+":/services_resource_dir";
        cout<<"视频服务 卷设置为: "<<svideoDir<<endl;
        vs.volumes.push_back(svideoDir);
    }
   this->mVessel.insert({name,vs});
   this->addServices(vs);
   return 0;
}














